package io.renren.modules.sp.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.renren.common.constant.Constant;
import io.renren.common.exception.RenException;
import io.renren.common.page.PageData;
import io.renren.common.service.impl.CrudServiceImpl;
import io.renren.common.utils.*;
import io.renren.modules.sp.dao.SpTeamDao;
import io.renren.modules.sp.dao.SpTeamUserDao;
import io.renren.modules.sp.dao.SpUserDao;
import io.renren.modules.sp.dto.SpUserDTO;
import io.renren.modules.sp.entity.SpTeamEntity;
import io.renren.modules.sp.entity.SpTeamUserEntity;
import io.renren.modules.sp.entity.SpUserEntity;
import io.renren.modules.sp.service.SpUserService;
import io.renren.modules.sys.dao.SysCommDao;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletResponse;
import java.net.URLEncoder;
import java.util.*;

/**
 * 用户
 *
 * @author whc 15953295779@126.com
 * @since 3.0 2023-04-21
 */
@Service
public class SpUserServiceImpl extends CrudServiceImpl<SpUserDao, SpUserEntity, SpUserDTO> implements SpUserService {
    @Autowired
    private SysCommDao commDao;
    @Autowired
    private SpTeamDao spTeamDao;
    @Autowired
    private SpTeamUserDao spTeamUserDao;
    @Autowired
    private CheckCodeUtils checkCodeUtils;

    @Override
    public QueryWrapper<SpUserEntity> getWrapper(Map<String, Object> params){
        QueryWrapper<SpUserEntity> wrapper = new QueryWrapper<>();

        String account = (String)params.get("account");
        wrapper.like(StringUtils.isNotBlank(account), "account", account);
        String phone = (String)params.get("phone");
        wrapper.like(StringUtils.isNotBlank(phone), "phone", phone);
        String email = (String)params.get("email");
        wrapper.like(StringUtils.isNotBlank(email), "email", email);
        String realName = (String)params.get("realName");
        wrapper.like(StringUtils.isNotBlank(realName), "real_name", realName);
        //身份证的搜索、与前台的身份证校验公用方法，所以不需要模糊查询
        String idCard = (String)params.get("idCard");
        wrapper.eq(StringUtils.isNotBlank(idCard), "id_card", idCard);
        String company = (String)params.get("company");
        wrapper.like(StringUtils.isNotBlank(company), "company", company);
        String roleId = (String)params.get("roleId");
        wrapper.like(roleId!=null, "role_id", roleId);

        return wrapper;
    }



    @Override
    public List<SpUserEntity> queryList(QueryWrapper<SpUserEntity> params){
        List<SpUserEntity> list = baseDao.selectList(params);
        return list;
    }
    /**
     * 检查身份证，手机号,是否唯一
     * */
    String checkPhoneCart(String phone ,String idCard){
        String sql ="select count(1) from  sp_user t where t.phone !=#{p.phone} and t.id_card= #{p.idCard}";

        Map<String,Object> param  = new HashMap<>();
        param.put("phone",phone);
        param.put("idCard",idCard);
        Integer count = commDao.count(sql,param);
        if(count>0){
            throw new RenException("该身份证已被其他账号占用！");
        }
        return null;
    }
    /**
     * 检查信息
     * */
    public String checkInfo(SpUserDTO user){
        checkPhoneCart(user.getPhone(),user.getIdCard());
        if(StringUtils.isNotBlank(user.getPhone())&&!MobilePhoneUtils.isMobilePhone(user.getPhone())){
            throw new RenException("手机格式不正确！");
        }
        //港澳居民来往内地通行证
        if("3".equals(user.getIdType())){
            if(!IdCardUtil.isHKCard(user.getIdCard())){
                throw new RenException("港澳居民来往内地通行证格式不正确！");
            }
        }
        if("4".equals(user.getIdType())){
            if(!IdCardUtil.isTWCard(user.getIdCard())){
                throw new RenException("台湾居民来往大陆通行证格式不正确！");
            }
        }
        return null;
    }

    @Override
    public Map<String,Object> queryUserById(Long userId){
        return baseDao.queryUserById(userId);
    }

    /**
     * 查询用户信息
     * @param loginInfo
     * @return
     */
    public Result<SpUserEntity> queryUser(SpUserDTO loginInfo){
        QueryWrapper<SpUserEntity> queryWrapper = new QueryWrapper<SpUserEntity>();
        queryWrapper.eq("phone",loginInfo.getPhone());
        queryWrapper.eq("real_name",loginInfo.getRealName());
        String roleIds = loginInfo.getRoleId();
        /**
         * 用户     表：  roleid   0代表队负责人 1领队 2老师 3选手
         * 代表队成员表：  type  1主领队 2领队 3老师 4选手
         *
         * 1、更换代表队负责人
         *    先查用户表属性为负责人(包含)，且没有绑定代表队的用户（1、2）
         * 2、添加领队
         *    先查用户表查出1领队(包含)，且没有绑定代表队的用户（1、2）
         * 3、添加老师
         *    先查用户表属性为2老师(包含)，不需要校验代表队成员表
         * 4、添加选手
         *   1、先查用户表属性为3选手(包含)，且没有绑定代表队的用户（4）
         *
         */

        // 前端添加不同身份时的入参roleId，不会出现多个值的情况:  0更换负责人 1添加领队 2添加老师 3添加选手
        if(StringUtils.isNotEmpty(roleIds)){
            List<SpUserEntity> userList = this.baseDao.selectList(
                    new QueryWrapper<SpUserEntity>()
                            .eq("phone", loginInfo.getPhone())
                            .eq("real_name", loginInfo.getRealName())
                            .like("role_id", roleIds)
            );
            if("0".equals(roleIds) || "1".equals(roleIds)){
                if(userList!=null && userList.size()>0) {
                    SpUserEntity userEntity = userList.get(0);
                    List<SpTeamUserEntity> tuList = spTeamUserDao.selectList(
                            new QueryWrapper<SpTeamUserEntity>()
                                    .eq("user_id", userEntity.getId())
                                    .in("type", 1, 2)
                    );
                    if(tuList!=null && tuList.size()>0){
                        return new Result<SpUserEntity>().error("当前用户已经参加了别的代表队");
                    }else{
                        return new Result<SpUserEntity>().ok(userList.get(0));
                    }
                }
            }else if("2".equals(roleIds)){
                if(userList!=null && userList.size()>0) {
                    return new Result<SpUserEntity>().ok(userList.get(0));
                }
            }else if("3".equals(roleIds)){
                if(userList!=null && userList.size()>0) {
                    SpUserEntity userEntity = userList.get(0);
                    List<SpTeamUserEntity> tuList = spTeamUserDao.selectList(
                            new QueryWrapper<SpTeamUserEntity>()
                                    .eq("user_id", userEntity.getId())
                                    .eq("type", 4)
                    );
                    if(tuList!=null && tuList.size()>0){
                        return new Result<SpUserEntity>().error("当前用户已经参加了别的代表队");
                    }else{
                        return new Result<SpUserEntity>().ok(userList.get(0));
                    }
                }
            }
        }
        return new Result<SpUserEntity>().error("用户不存在，或者用户类型不正确");
    }


    /**
     * 更新用户类型
     * 1、如果代表队负责人，没有实际创建代表队，可以更换
     * @param phone
     * @param roleId
     * @return
     */
    public Result<String> updateUserType(String phone, String roleId){
        QueryWrapper<SpUserEntity> queryWrapper = new QueryWrapper<SpUserEntity>();
        queryWrapper.eq("phone", phone);
        List<SpUserEntity> userList = baseDao.selectList(queryWrapper);
        if (userList != null && userList.size() > 0) {
            SpUserEntity user = userList.get(0);
            //user.setId(loginInfo.getId());
            //判断新输入的用户类型是否合法
            //String roleId = loginInfo.getRoleId();
            //正则校验roleId只能包含数字和逗号
            if(!roleId.matches("^[0-9,]+$")){
                return new Result<String>().error("用户类型错误");
            }
            // 取系统中存在的用户类型
            String userRoleIds = user.getRoleId();
            // 0    0,2  0->3  0,2->3  1->0
            if(userRoleIds.contains("0")) {
                List<SpTeamEntity> teamList = spTeamDao.selectList(new QueryWrapper<SpTeamEntity>()
                        .eq("creator", user.getId())
                );
                if(teamList!=null && teamList.size()>0){
                    return new Result<String>().error("代表队负责人已创建代表队，不能更换用户类型");
                }
            }
            //选手
            if(userRoleIds.contains("3")) {
                List<SpTeamUserEntity> tuList = spTeamUserDao.selectList(
                        new QueryWrapper<SpTeamUserEntity>()
                                .eq("user_id", user.getId())
                                .eq("type", 4)
                );
                if (tuList != null && tuList.size() > 0) {
                    for (SpTeamUserEntity tu : tuList) {
                        spTeamUserDao.deleteById(tu.getId());
                    }
                }
            }
            //领队、指导老师 1,2 -> 0,2
            if(userRoleIds.contains("1") || userRoleIds.contains("2")) {
                //team_user type: 1主领队 2领队 3老师 4选手
                List<SpTeamUserEntity> tuList = spTeamUserDao.selectList(
                        new QueryWrapper<SpTeamUserEntity>()
                                .eq("user_id", user.getId())
                                .in("type", 1, 2, 3)
                );
                if (tuList != null && tuList.size() > 0) {
                    for (SpTeamUserEntity tu : tuList) {
                        spTeamUserDao.deleteById(tu.getId());
                    }
                }
            }
            //修改成新的用户类型
            user.setRoleId(roleId);
            baseDao.updateById(user);
            return new Result<String>().ok("修改成功");
        }else{
            return new Result<String>().error("用户不存在");
        }

    }

    @Override
    public Result<String> upgradeTeacher(Long userId, String password) {
        SpUserEntity user = baseDao.selectById(userId);
        if (user != null) {
            //校验短信码
            if (!checkCodeUtils.verifyCheckCode(user.getPhone(), password)) {
                return new Result<String>().error("验证码错误,请重新获取");
            }
            //判断是不是选手
            String roleId = user.getRoleId();
            if (!roleId.contains("3")) {
                throw new RenException("用户不是选手，不能升级为老师");
            }
            //判断是否挂在代表队
            List<SpTeamUserEntity> tuList = spTeamUserDao.selectList(
                    new QueryWrapper<SpTeamUserEntity>()
                            .eq("user_id", userId)
                            .eq("type", 4)
            );
            if (tuList != null && tuList.size() > 0) {
                throw new RenException("用户挂在代表队，不能升级为老师");
            }
            user.setRoleId("2");
            baseDao.updateById(user);
        }
        return new Result<String>().ok("升级成功");
    }

    /**
     * 增补指导老师用户类型
     * @param userId
     * @param password
     * @return
     */
    @Override
    public Result<String> addTeacherUserType(Long userId, String password) {
        SpUserEntity user = baseDao.selectById(userId);
        if (user != null) {
            //校验短信码
            if (!checkCodeUtils.verifyCheckCode(user.getPhone(), password)) {
                return new Result<String>().error("验证码错误,请重新获取");
            }
            //判断是不是选手
            String roleId = user.getRoleId();
            if (roleId.contains("3")) {
                throw new RenException("用户是选手，不能增补为老师");
            }
            user.setRoleId(user.getRoleId()+",2");
            baseDao.updateById(user);
        }
        return new Result<String>().ok("升级成功");
    }


}
